The BridgeDb DataSource Ontology

This example uses the BridgeDb DataSource Ontology, created by BridgeDb developers from Manchester University (Christian, Stian, and Alasdair). The ontology covers describing data sources of identifiers, a technology outlined in the BridgeDb paper by Martijn (see below) as well as terms from the Open PHACTS Dataset Descriptions for the Open Pharmacological Space by Alasdair et al.

Because I needed to put this online for Open PHACTS (BTW, the project won a big award!) and our previous solution did not work well enough anymore. You may also see the HTML of the result first. You may also want to verify it really is HTML: here is the HTML5 validation report. Also, you may be interested in what the ontology in RDF looks like: here is the extracted RDF for the ontology. Now follow the HTML+RDFa snippets. First, the ontology details (actually, I have it split up):

<div about="http://vocabularies.bridgedb.org/ops#"
     typeof="owl:Ontology">
  <h1>The <span property="rdfs:label">BridgeDb DataSource Ontology</span>
    (version <span property="owl:versionInfo">2.1.0</span>)</h1>
  <p>
    This page describes the BridgeDb ontology. Make sure to visit our
    <a property="rdfs:seeAlso" href="http://www.bridgedb.org/">homepage</a> too!
  </p>
</div>
<p about="http://vocabularies.bridgedb.org/ops#">
  The OWL ontology can be extracted
  <a property="owl:versionIRI"
     href="http://www.w3.org/2012/pyRdfa/extract?uri=http://vocabularies.bridgedb.org/ops#">here</a>.
  The Open PHACTS specification on
  <a property="rdf:seeAlso"
    href="http://www.openphacts.org/specs/2013/WD-datadesc-20130912/#bridgedb"
  >Dataset Descriptions</a> is also useful.
</p>

This is the last time I show the custom color coding, but for a first time it is useful. In red are basically the predicates, where @about indicates a new resource is started, @typeof defines the rdf:type, and @property indicates all other predicates. The blue and green blobs are literals and object resources, respectively. If you work this out, you get this OWL code (more or less):

bridgedb: a owl:Ontology;
  rdfs:label "BridgeDb DataSource Ontology"@en;
  rdf:seeAlso
    <http://www.openphacts.org/specs/2013/WD-datadesc-20130912/#bridgedb>;
  rdfs:seeAlso <http://www.bridgedb.org/>;
  owl:versionIRI
    <http://www.w3.org/2012/pyRdfa/extract?uri=http://vocabularies.bridgedb.org/ops#>;
  owl:versionInfo "2.1.0"@en .

An OWL class

Defining OWL classes are using the same approach: define the resource it is @about, define the @typeOf and giving is properties. BTW, note that I added a @id so that ontology terms can be looked up using the HTML # functionality. For example:

<div id="DataSource"
  about="http://vocabularies.bridgedb.org/ops#DataSource"
  typeof="owl:Class">
  <h3 property="rdfs:label">Data Source</h3>
  <p property="dc:description">A resource that defines
    identifiers for some biological entity, like a gene,
    protein, or metabolite.</p>
</div>

An OWL object property

Defining an OWL data property is pretty much the same, but note that we can arbitrary add additional things, making use of <span>, <div>, and <p> elements. The following example also defines the rdfs:domain and rdfs:range:

<div id="aboutOrganism"
  about="http://vocabularies.bridgedb.org/ops#aboutOrganism"
  typeof="owl:ObjectProperty">
  <h3 property="rdfs:label">About Organism</h3>
  <p><span property="dc:description">Organism for all entities
    with identifiers from this datasource.</span>
    This property has
    <a property="rdfs:domain"
      href="http://vocabularies.bridgedb.org/ops#DataSource">DataSource</a>
    as domain and
    <a property="rdfs:range"
      href="http://vocabularies.bridgedb.org/ops#Organism">Organism</a>
    as range.</p>
</div>

So, now anyone can host an OWL ontology with dereferencable terms: to remove confusion, I have used the full URLs of the terms in @about attributes.

One of the things, is that the CiTO data added via a certain account, can be downloaded as triples:

The second is that they are improving the graphics of how it is visualized. E.g. they added an ‘Expand’ link, which I found when they tweeted they had hidden drag-n-drop, which I haven’t found yet, though. Clicking that action, will show you the following:

Because CiteULike takes advantage of the inverse function of the CiTO predictates, they show up with the cited paper too, which is less suitable for the top-down flow graphics:

To make this advertorial a bit balanced, not all my wishes have been implemented yet, and the next up from my perspective should be Linked Data. There is some Linked Data embedded as RDFa, but the latter is not turning out to be the killer I had hoped, and regular RDF entry points should be used.

Each CiteULike entry (post) should get a unique IRI (or URI) and opening that link should give RDF about that post (wish #10). That’s is dereferencibility. The RDF can be, for example, in BIBO but there are many alternatives, and I have not been keeping up with which is the best (please leave a comment, if you have an opinion on that).

But I like where this is going! Thanx, CiteIReallyLikeThis!

Then Google Scholar Citations (GSC) shows up. While it does not look as pretty as competing products, it compensates that with a wide coverage of literature (for example, it supports the JChemInf, which Web-of-Science currently does not; and I happen to publish a lot in that journal recently), books, and reports, while keeping false positives fairly low. Thus, it provides an upper limit of my citations statistics, but one I am pretty happy confident about. And my H-index is quite comparable anyway. This is what my profile looks like:

So, these statistics have two purposes to me: 1. grant applications, and 2. I like to know what people based theirs on my research. (Well, OK, 3. it helps me understand why I work so hard on too many things.)

Now the question is, will GSC take off. Will it replace ORCID? Will they join ORCID? Will GSC get a good API? Who will write the first userscript to make the GUI fancier? Will GSC support CiTO? Will GSC start using microformats or RDFa? What mashups can we expect between bibliographic databases? Will new entries automatically be posted to Google+? Will it have a button to autocreate a blog post when a paper gets cited 100, 500, or a 1000 times? Will GSC support #altmetrics?

Before I start, I like to put some emphasize on the following RDFa pattern. An RDF resource that serves as subject is always mapped to a HTML element. This can be a div element, but also other elements, as we will see in the example.

A molecule SMILES

The oldest RDFa example in my blog is from

1. That was almost two years before the final Recommendation, and is not quite accurate anymore. But here’s the correct version:

This example shows how to embed the SMILES string CCO semantically. This example shows that the outer most span element is used to define the subject of the RDF triple, using the @about attribute to define the URI of the resource: #ethanol. Note that this URI is relative to the URI of the HTML page in which it is embedded. Later we will see an example with a full URI.

But I don’t want to hack HTML!

Yeah, fair point. Just make a point with your publisher when you submit a new paper. It is the duty of the publisher and your software vendor to do this right. In 2008 I wrote a small Ubiquity script to automagically convert an InChI into semantified HTML content. But I am not sure this script still works. If interesting, let me know, and I will revive the Firefox thingy.

And why would I want to do it anyway??

Because software can more easily understand what you mean. This is why Google is now pushing rich snippets. Chemical blogspace understands them too, allowing you to see blog posts about molecules on other webpages. With a simple bit of JavaScript you can link from your webpages, you can enrich your HTML sites with semantic chemistry yourself. Bioclipse also has no problem with extracting the RDF from HTML. Even Firefox can understand it. Really, there is no end to it.

Of course, why you should do this comes basically down to Molecular Chemometrics Principle #2, but I have not written that on up yet (see also McPrinciple #1).

Reporting problems with molecular representations

More recently, I reported about using RDFa in human readable log file for computations I am doing (see Scripts logs as HTML+RDFa: mix free text reporting with CSV). That code looks like:

This example uses a div element to host the subject resource. Again, the resource URI is relative to the URI of the document, e.g. this one. We can also note a new attribute, @typeof, which is here used to define the rdf:type of the #200234 resource.

This code snippet does not define the um namespace, which was done elsewhere in the HTML. Moreover, this code snippet does not actually reuse existing ontologies, which is highly recommended. The upcoming RDF symposium in Boston will tell you all about chemical ontologies in the RDF world (see this detailed program, which itself is HTML+RDFa!). But, if you would just overlook the ad hoc namespaces used, you might appreciate the nesting: besides the compound (#200234), a second resource is defined (#error0). In total, this example contains six triples.

Meanwhile, the output simply looks like:

A molecule table

This third, and for now last, example shows several other features. This HTML snippet show a one entry molecule table, very much like those molecular spreadsheets in Excel, but than right here in your webbrowser. (Can you imagine what happens if we mash this up with JavaScript molecular viewers

First of all, the rdf.openmolecules.net project is used to construct an absolute URI for the molecule. The table then gives some properties of the molecule: its name (using Dublin Core, though perhaps rdfs:label is better), the boiling point (nicely encoded as t0 in this 1947 paper), two cheminformatics descriptors, and the SMILES, using the same approach as the first example in this post.

The output of this table looks like:

I will shortly blog about the source of the above code snippet, but you are invited to go ahead and checkout my GitHub activity (RSS).

Steffen, I think these examples should get you pretty far, but please let me know if you have further questions!

One technical approach to implement the idea of adding semantic to text in HTML pages is RDFa. But with any technology, scientists seems to have an in-built deficiency of thinking clearly, and anything beyond being able to format your bibliography with the correct bold and italic seems to be a bit much asked.

Anyway, for future reference, this is a basic HTML framework for embedding RDFa:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML+RDFa 1.0//EN"
    "http://www.w3.org/MarkUp/DTD/xhtml-rdfa-1.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"
    version="XHTML+RDFa 1.0" xml:lang="en">
  <head>
    <title>ACS RDF Symposium, Boston, August 2010</title>
  </head>
  <body>
  </body>
</html>

Perhaps you prefer the raw source.

Two days later, today, I ran my first analysis. Still a test run, but using the CDK to perceive atom types on the first 2.5 GB of PubChem data. The full data set is now 80 GB, and I will start doing this analysis today. You might remember this already two years ago (see Wicked chemistry and unit testing) for a small subset, but only now have the power to analyze all compounds. The UPPMAX system I work on has 348, each with 8 cores. Each core has 3 GB of memory, but I am using the IteratingPCCompoundXMLReader class anyway. Analyzing the 2.5 GB of data was done using 50 nodes, and finished in about a minute. Nice :)

Now, this first run dumped the results as a plain text file, looking like:

CID 200234: Ti  1
CID 200235: Ti 1
CID 200237: Sb 1 Sb 2
CID 200365: S 1
CID 200761: Hg 1
CID 201374: Ce 1 Ce 2
CID 201395: As 1 

Simple and effective.

Or? And this is where the two items outlined in the first paragraph meet. No, this is not useful. Since the output is from an analysis of PubChem, I’m sure you already figured out that the first two columns indicate the compound being analyzed. You might also work out that then the elements are given for which the atom type perception failed. You may even figure out that the number is likely to be the index in the connection table representation of the molecule. Right?

But what about machine readability? I could, of course, write the output as CSV, but then I would loose my ability to write the report in human readable format. And moreover, the list of failing atom types does not have a fixed length, as you can see in the example lines given earlier.

Now, this is where RDF comes in. If I create my output as HTML+RDFa, I can do fancy stuff. My results page could link directly to PubChem, so that I can inspect the actual compound. Though I could do that even with merely HTML. But with RDFa, I can actually make my free text log output machine readable. I can accurately annotate what bits are informative:

<div about="#200234" typeof="um:Compound">CID
  <span property="um:cid" datatype="xsd:integer">200234</span>:
  <span rel='um:hasProblem'>
    <span about='#error0' typeof='um:Problem'>
      <span property='um:hasElement'>Ti</span>
      <span property='um:hasIndex' datatype='xsd:integer'>1</span>
    </span>
  </span>
</div>

The file is not backed up by an OWL ontology, but where possible one would do that. Reuse of ontologies is a good thing (e.g. use a service like Schemapedia).

Now, I can easily open up this file in a web browser (follow this link) and get the same view as above. But I can also import the file directly into Bioclipse (see Semantic Web features in Bioclipse 2.2), or in any other tool that supports RDFa. I can then use SPARQL to do some first analysis, for example, with:

PREFIX um: <http://egonw.github.com/uppmax>

SELECT ?elem (count(*) AS ?count) WHERE {
  ?compound um:cid ?cid;
     um:hasProblem ?problem .
  ?problem um:hasElement ?elem .
} GROUP BY ?elem ORDER BY ?elem

Combine that with the RDFaDev tool I wrote about last week (see RDFaDev: HTML+RDFa development with FireFox). Now you should get some feeling of the advantages of using Open Standards: I can do some initial analysis of the results, just right there in the web browser you have open anyway:

Therefore, next time you ask your data analyst to perform some calculation, insist that he sends you HTML+RDFa log files with results. Better, ask him to put it online, and you immediately reach Step 3 in the analysis by David.

http://egonw.github.com/acsrdf2010/

I am excited that on Monday afternoon Eric Prud’hommeaux will present the work of the LODD working group to the chemistry community. The symposium contains three half day sessions with topics on computing, ontologies, and applications, all chemistry oriented. The goal of the meeting is to get together people using RDF technologies in chemistry, and the list of talks from around the world shows that this goal has been reached. The program is diverse and exciting, and I am very much looking forward to meeting all participants to discuss challenges and cool solutions.

People interested in joining, can sign up to the meeting mailing list. Besides that the webpage is in XHTML+RDFa, the source is also available on GitHub (well, you really download the source code anyway), allowing people to happily fork, make changes, and perhaps make the page as triple-dense as is possible.

I am also keen to have mastered some jQuery skills, and the Abstract links on the webpage use jQuery to show and hide them.

Now, addressing the limitations of the current citation databases is technically simple, and purely blocked by social and commercial aspects. The Citation Typing Ontology by David Shotton defines the framework to define citation types, independent from any existing database. The semantic web technologies will take it from there, and allow aggregation etc.

There are some things to think about on how to use such citation networks, though. If we calculate the impact of the CDK project, we should combine citation counts to the website(s), papers, etc, after removal of duplicates, etc. The cito:cites does link to resources, and the CDK paper resources is not the same as the CDK website resource. But, we could define a Project Class, where both are foo:partOf. Then, we could define that the triple chain the:citingWork cito:cites the:CDKArticle foo:partOf the:CDKProject would imply the triple the:citingWork cito:cites the:CDKProject.

Typed Citations

Now, while writing up this blog, I realize that my fork of this morning, A BIBO Citation Typing Ontology, might actually be counter-productive in the long run, as I was only working out a solution to a simpler, but different problem, which the CiTO also addresses: a citation is not typed. When a paper does cite the CDK paper, we still do not know if it uses the CDK, or merely mentioned it as related-but-unused, or even refuted work.

Now, as I am leaning towards the Biobliography Ontology as RDF-based system for my references, and been using this already in the RDF store hosting the ChEMBL data, I forked the CiTO to define rdfs:domain and rdfs:range on bibo:Document. The CiTO 1.5 actually defines a large set of document types too, and I rather see BIBO reused.

This indeed has the downside that the bibocto:cites cannot be used for the above chaining, and this might bite me seriously later. Well, nothing wrong with a failing experiment, right? For now, it will serve my purpose: setting up a citation database for the CDK project papers.

The CDK citation database

So, here goes (it’s RDFa-enabled; check this RDF pulled out):

@prefix bibo: <http://purl.org/ontology/bibo/>.
@prefix bibocto: <http://github.com/egonw/bibo-cto/>.

<urn:doi:10.1186/1758-2946-2-1> a bibo:Article ;
  bibocto:cites <urn:doi:10.1021/ci025584y> .

I am not entirely happy about the error-prone XHTML+RDFa of the above example, and filed a question of better solution on SemanticOverflow.

While the above example merely defines the citation of Peter Ertl’s article to the CDK (whether that is valid or not… would he have cited the other paper perhaps?), the citation typing allows me to state how the CDK paper is cited. Now, Peter states:

It is also gratifying to see the advent of open source movement in cheminformatics on the Internet, as advocated for example by the Blue Obelisk Group (40) and witnessed by collaborative projects like Chemistry Development Kit CDK (41), Jmol (42), Bioclipse (43) and several others.

So, I think it is fair to state that:

<urn:doi:10.1186/1758-2946-2-1> bibocto:credits <urn:doi:10.1021/ci025584y> .

which is very much appreciated!

• Bioclipse Manager for MyExperiment.org
• Bioclipse, RDF and defeasible reasoning (see also Samuel’s blog)
• Bioclipse and SPARQL end points #2: MyExperiment
• Bioclipse and SPARQL end points
• Solubility Data in Bioclipse #2: handling RDF
• Solubility Data in Bioclipse #3: Finding ChEBI IDs
• Solubility Data in Bioclipse #4: Finding ChEBI IDs (Again, but better)
• /me is having Bioclipse/XMPP/RDF fun

Or check this screenshot from a Posterous post about a MyExperiment workflow :

One thing I have not blogged about yet (I think), is that the Bioclipse RDF manager also understands RDFa now. Well, sort of… it relies on a webservice, but this is what the script looks like:

model = rdf.createStore()
rdf.importRDFa(model, "http://egonw.github.com/")
rdf.saveRDFN3(model, "/Virtual/egonw.n3")

With support of SPARQL end points, and reading RDF from web resources directly (RDF/XML, N3, RDFa), Bioclipse is ready for the chemical semantic web.